<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>手写Promise</title>
</head>
<body>
  <script>
    // 手写Promise
    // 1：写constructor构造函数，传参为callback，定义初始值，初始化状态为 pending，初始化成功，失败状态的值为 undefined。定义resolve，reject函数，如果为pending，就更改状态，调用回调函数，将 resolve 和 reject 传递给它
    // 2：写then函数，参数为onResolved, onRejected，判断传参类型，如果不是函数类型就转成函数类型，然后创建一个新的Promise对象，
    // 如果当前 Promise 的状态为 resolved，执行 onResolved 回调函数，处理返回值，如果回调函数抛出异常，将异常作为失败状态的值；
    // 如果当前 Promise 的状态为 rejected，执行 onRejected 回调函数，处理返回值，如果回调函数抛出异常，将异常作为失败状态的值；
    // 如果当前 Promise 的状态为 pending，将 onResolved 和 onRejected 保存起来，等待异步操作完成后再执行，执行完所有回调函数之后，清空回调数组
    // 返回新的 Promise 对象
    // 3：写catch函数，传参为onRejected，return this.then(null, onRejected);
    class MyPromise {
      constructor(callback) {
        // 初始化状态为 pending
        this.status = 'pending';
        // 初始化成功状态的值
        this.value = undefined;
        // 初始化失败状态的值
        this.reason = undefined;

        // 定义 resolve 函数
        const resolve = value => {
          if (this.status === 'pending') {
            // 更新状态为 resolved
            this.status = 'resolved';
            // 存储成功状态的值
            this.value = value;
          }
        };

        // 定义 reject 函数
        const reject = reason => {
          if (this.status === 'pending') {
            // 更新状态为 rejected
            this.status = 'rejected';
            // 存储失败状态的值
            this.reason = reason;
          }
        };

        // 调用回调函数，将 resolve 和 reject 传递给它
        callback(resolve, reject);
      }
      then(onResolved, onRejected) {
        onResolved = typeof onResolved === "function" ? onResolved : (value) => value;
		    onRejected = typeof onRejected === "function" ? onRejected : (reason) => { throw reason };
        // 创建一个新的 Promise 对象
        const newPromise = new MyPromise((resolve, reject) => {
          // 如果当前 Promise 的状态为 resolved
          if (this.status === 'resolved') {
            try {
              // 执行 onResolved 回调函数
              const x = onResolved(this.value);
              // 处理返回值
              resolve(x);
            } catch (error) {
              // 如果回调函数抛出异常，将异常作为失败状态的值
              reject(error);
            }
          }

          // 如果当前 Promise 的状态为 rejected
          if (this.status === 'rejected') {
            try {
              // 执行 onRejected 回调函数
              const x = onRejected(this.reason);
              // 处理返回值
              resolve(x);
            } catch (error) {
              // 如果回调函数抛出异常，将异常作为失败状态的值
              reject(error);
            }
          }

          // 如果当前 Promise 的状态为 pending
          if (this.status === 'pending') {
            // 将 onResolved 和 onRejected 保存起来
            // 等待异步操作完成后再执行
            this.onResolvedCallbacks.push(() => {
              try {
                const x = onResolved(this.value);
                resolve(x);
              } catch (error) {
                reject(error);
              }
            });
            this.onRejectedCallbacks.push(() => {
              try {
                const x = onRejected(this.reason);
                resolve(x);
              } catch (error) {
                reject(error);
              }
            });
          }else {
						// 执行完所有回调函数之后，清空回调数组
						this.onResolvedCallbacks = [];
						this.onRejectedCallbacks = [];
					}
        });
        // 返回新的 Promise 对象
        return newPromise;
      }
      catch(onRejected) {
        return this.then(null, onRejected);
      }
    }
    function sum(){
      return new MyPromise((resolve,reject)=>{
        let number = Math.random()
        console.log(number)
        if(number<0.5){
          resolve('成功')
        }else{
          reject('失败')
        }
      })
    }
    sum().then(res=>console.log(res)).catch(err=>console.log(err))
    // sum().catch(err=>console.log(err))
    // sum().then(res=>console.log(res))
  </script>
</body>
</html>